home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 #2 / Ham Radio 2000 - Volume 2.iso / HAMV2 / TCP_IP / TNOS230S / SCRIPT.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-07-30  |  12.9 KB  |  708 lines
  1. #include "global.h"
  2. #include "ctype.h"
  3. #include "commands.h"
  4. #include "mbuf.h"
  5. #include "proc.h"
  6. #include "assoc.h"
  7. #include "socket.h"
  8.  
  9. #if !defined(_lint)
  10. static char rcsid[] OPTIONAL = "$Id: script.c,v 1.14 1997/07/31 00:44:20 root Exp root $";
  11. #endif
  12.  
  13. #ifdef SCRIPTING
  14. static AarrayPtr Aliases = NULLASSOC;
  15. AarrayPtr SetVariables = NULLASSOC;
  16.  
  17. extern struct cmds Cmds[];
  18. extern const char hitEnter[];
  19. extern int MAttended;
  20.  
  21. #ifdef ALLSERV
  22. extern int Attended;
  23. #endif
  24.  
  25. static void _adjust (char *label, int offset);
  26. void variable_expansion (struct mbuf ** bp);
  27.  
  28. static int _ifdef (int argc, char *argv[], int notflag);
  29. static int _ifequal (int argc, char *argv[], int notflag);
  30. static int doifequal (int argc, char *argv[], void *p);
  31. static int doifnequal (int argc, char *argv[], void *p);
  32. static int doifless (int argc, char *argv[], void *p);
  33. static int doifgreat (int argc, char *argv[], void *p);
  34. static int doiflessequal (int argc, char *argv[], void *p);
  35. static int doifgreatequal (int argc, char *argv[], void *p);
  36. static int _ifstrequal (int argc, char *argv[], int notflag);
  37. static int doifstrequal (int argc, char *argv[], void *p);
  38. static int doifnstrequal (int argc, char *argv[], void *p);
  39.  
  40. #define _EQUAL        0
  41. #define _NEQUAL        1
  42. #define _LESS        2
  43. #define _GREAT        3
  44. #define _LESSEQUAL    4
  45. #define _GREATEQUAL    5
  46.  
  47.  
  48. int
  49. dogone (argc, argv, p)
  50. int argc OPTIONAL;
  51. char *argv[] OPTIONAL;
  52. void *p OPTIONAL;
  53. {
  54. #ifdef ALLSERV
  55.     Attended = FALSE;
  56. #endif
  57. #ifdef MAILBOX
  58.     MAttended = FALSE;
  59. #endif
  60.     return 0;
  61. }
  62.  
  63.  
  64. int
  65. dohere (argc, argv, p)
  66. int argc OPTIONAL;
  67. char *argv[] OPTIONAL;
  68. void *p OPTIONAL;
  69. {
  70. #ifdef ALLSERV
  71.     Attended = TRUE;
  72. #endif
  73. #ifdef MAILBOX
  74.     MAttended = TRUE;
  75. #endif
  76.     return 0;
  77. }
  78.  
  79.  
  80. int
  81. dosleep (argc, argv, p)
  82. int argc;
  83. char *argv[];
  84. void *p OPTIONAL;
  85. {
  86. int32 len = 0;
  87.  
  88.     if (argc > 1)
  89.         len = atol (argv[1]);
  90.     if (argc < 3 || tolower (*argv[2]) != 'm')
  91.         len = (!len) ? 1000 : (len * 1000);
  92.     (void) kpause (len);
  93.     return 0;
  94. }
  95.  
  96.  
  97. int
  98. dopause (argc, argv, p)
  99. int argc;
  100. char *argv[];
  101. void *p;
  102. {
  103. struct mbuf *bp;
  104.  
  105.     if (argc == 2)        /* if a param given, use as a minimum delay */
  106.         (void) dosleep (argc, argv, p);
  107.  
  108.     tputs (hitEnter);
  109.     tflush ();
  110.     (void) recv_mbuf (Curproc->input, &bp, 0, NULLCHAR, 0);
  111.     return 0;
  112. }
  113.  
  114.  
  115. int
  116. doecho (argc, argv, p)
  117. int argc;
  118. char *argv[];
  119. void *p OPTIONAL;
  120. {
  121. int k;
  122. int docr = 1;
  123.  
  124.     for (k = 1; k < argc; k++) {
  125.         if (k == 1 && !strcmp (argv[k], "-n")) {
  126.             docr = 0;
  127.             continue;
  128.         }
  129.         if (!strncmp (argv[k], "$(", 2) && argv[k][strlen (argv[k]) - 1] == ')') {    /* command substitution */
  130.             argv[k][strlen (argv[k]) - 1] = 0;
  131.             (void) cmdparse (Cmds, &argv[k][2], NULL);
  132.         } else {
  133.             tputs (argv[k]);
  134.             tputc (' ');
  135.         }
  136.     }
  137.     if (docr)
  138.         tputc ('\n');
  139.     tflush ();
  140.     return 0;
  141. }
  142.  
  143.  
  144. int
  145. doalias (argc, argv, p)
  146. int argc;
  147. char *argv[];
  148. void *p OPTIONAL;
  149. {
  150.     if (argc < 3)
  151.         assoc_list (Aliases, 15, (argc == 1) ? NULLCHAR : argv[1]);
  152.     else
  153.         (void) assoc_addstr (&Aliases, argv[1], argv[2], 1);
  154.  
  155.     return 0;
  156. }
  157.  
  158.  
  159. int
  160. dounalias (argc, argv, p)
  161. int argc OPTIONAL;
  162. char *argv[];
  163. void *p OPTIONAL;
  164. {
  165.     (void) assoc_free (&Aliases, argv[1]);
  166.     return 0;
  167. }
  168.  
  169.  
  170. int
  171. doset (argc, argv, p)
  172. int argc;
  173. char *argv[];
  174. void *p OPTIONAL;
  175. {
  176.     if (argc < 3)
  177.         assoc_list (SetVariables, 15, (argc == 1) ? NULLCHAR : argv[1]);
  178.     else
  179.         (void) assoc_addstr (&SetVariables, argv[1], argv[2], 1);
  180.  
  181.     return 0;
  182. }
  183.  
  184.  
  185. int
  186. dounset (argc, argv, p)
  187. int argc OPTIONAL;
  188. char *argv[];
  189. void *p OPTIONAL;
  190. {
  191.     (void) assoc_free (&SetVariables, argv[1]);
  192.     return 0;
  193. }
  194.  
  195.  
  196. static void
  197. _adjust (label, offset)
  198. char *label;
  199. int offset;
  200. {
  201. char *valstr;
  202. int value = 0;
  203. char buf[24];
  204.  
  205.     if ((valstr = (char *)assoc_lookup (SetVariables, label)) != NULLCHAR)
  206.         value = atoi (valstr);
  207.  
  208.     value += offset;
  209.     sprintf (buf, "%-d", value);
  210.     (void) assoc_addstr (&SetVariables, label, buf, 1);
  211. }
  212.  
  213.  
  214. int
  215. doincr (argc, argv, p)
  216. int argc;
  217. char *argv[];
  218. void *p OPTIONAL;
  219. {
  220. int offset = 1;
  221.  
  222.     if (argc > 2)
  223.         offset = atoi (argv[2]);
  224.     _adjust (argv[1], offset);
  225.     return 0;
  226. }
  227.  
  228.  
  229. int
  230. dodecr (argc, argv, p)
  231. int argc;
  232. char *argv[];
  233. void *p OPTIONAL;
  234. {
  235. int offset = -1;
  236.  
  237.     if (argc > 2)
  238.         offset = (atoi (argv[2]) * -1);
  239.     _adjust (argv[1], offset);
  240.     return 0;
  241. }
  242.  
  243.  
  244. int
  245. dogoto (argc, argv, p)
  246. int argc;
  247. char *argv[];
  248. void *p OPTIONAL;
  249. {
  250.     if (argc == 1) {
  251.         if (Curproc->gotolabel)
  252.             tprintf ("goto: %s\n", Curproc->gotolabel);
  253.     } else {
  254.         if (Curproc->gotolabel)
  255.             free (Curproc->gotolabel);
  256.         Curproc->gotolabel = strdup (argv[1]);
  257. #if 0
  258.         tprintf ("Skipping command till label '%s'\n", Curproc->gotolabel);
  259. #endif
  260.     }
  261.     return 0;
  262. }
  263.  
  264.  
  265. int
  266. dolabel (argc, argv, p)
  267. int argc;
  268. char *argv[];
  269. void *p OPTIONAL;
  270. {
  271.     if (argc == 1) {
  272.         if (!Curproc->gotolabel)
  273.             return 0;
  274.         tprintf ("label: goto '%s' cleared\n", Curproc->gotolabel);
  275.         goto clear;
  276.     }
  277.     if (Curproc->gotolabel && !strcmp (Curproc->gotolabel, argv[1])) {
  278. clear:        free (Curproc->gotolabel);
  279.         Curproc->gotolabel = NULLCHAR;
  280.     }
  281.     return 0;
  282. }
  283.  
  284.  
  285. int
  286. doforeach (argc, argv, p)
  287. int argc OPTIONAL;
  288. char *argv[];
  289. void *p;
  290. {
  291. char *lpt = argv[2];
  292. char *next, *cp;
  293.  
  294.     while (*lpt) {
  295.         next = skipnonwhite (lpt);
  296.         if (*next) {
  297.             *next++ = 0;
  298.             next = skipwhite (next);
  299.         }
  300.         (void) assoc_addstr (&SetVariables, argv[1], lpt, 1);
  301.         cp = _variable_expansion (strdup (argv[3]));
  302.         (void) cmdparse (Cmds, cp, p);
  303.         lpt = next;
  304.     }
  305.     return 0;
  306. }
  307.  
  308.  
  309. /* if subcommand table */
  310. static struct cmds IFtab[] =
  311. {
  312.     { "==",        doifequal,    0, 4, "if|while|until string == string2 {cmd}"  },
  313.     { ">",        doifgreat,    0, 4, "if|while|until string > string2 {cmd}"   },
  314.     { ">=",        doifgreatequal,    0, 4, "if|while|until string >= string2 {cmd}"  },
  315.     { "<",        doifless,    0, 4, "if|while|until string < string2 {cmd}"   },
  316.     { "<=",        doiflessequal,    0, 4, "if|while|until string <= string2 {cmd}"  },
  317.     { "!=",        doifnequal,    0, 4, "if|while|until string != string2 {cmd}"  },
  318.     { "eq",        doifstrequal,    0, 4, "if|while|until string eq string2 {cmd}"  },
  319.     { "!eq",    doifnstrequal,    0, 4, "if|while|until string !eq string2 {cmd}" },
  320.     { NULLCHAR,    NULL,        0, 0, NULLCHAR}
  321. };
  322.  
  323.  
  324. int
  325. doif (argc, argv, p)
  326. int argc;
  327. char *argv[];
  328. void *p;
  329. {
  330. int retval, swapped = 0;
  331. char *cp;
  332.  
  333.     if (argc >= 3) {
  334.         cp = argv[1];
  335.         argv[1] = argv[2];
  336.         argv[2] = cp;
  337.         swapped = 1;
  338.     }
  339.     if ((retval = subcmd (IFtab, argc, argv, p)) > 0)    {
  340.         if (!Curproc->condfalse) {
  341.             cp = _variable_expansion (strdup (argv[retval]));
  342.             retval = cmdparse (Cmds, cp, NULL);
  343.             free (cp);
  344.         } else
  345.             retval = 0;
  346.     }
  347.     if (swapped) {
  348.         cp = argv[1];
  349.         argv[1] = argv[2];
  350.         argv[2] = cp;
  351.     }
  352.     return retval;
  353. }
  354.  
  355.  
  356. int
  357. doelse (argc, argv, p)
  358. int argc OPTIONAL;
  359. char *argv[];
  360. void *p OPTIONAL;
  361. {
  362. int retval = 0;
  363. char *cp;
  364.  
  365.     if (Curproc->condfalse) {
  366.         cp = _variable_expansion (strdup (argv[1]));
  367.         retval = cmdparse (Cmds, cp, NULL);
  368.         free (cp);
  369.     }
  370.     return retval;
  371. }
  372.  
  373.  
  374. int
  375. doifdef (argc, argv, p)
  376. int argc;
  377. char *argv[];
  378. void *p OPTIONAL;
  379. {
  380.     return (_ifdef (argc, argv, 0));
  381. }
  382.  
  383.  
  384. int
  385. doifndef (argc, argv, p)
  386. int argc;
  387. char *argv[];
  388. void *p OPTIONAL;
  389. {
  390.     return (_ifdef (argc, argv, 1));
  391. }
  392.  
  393.  
  394. int
  395. _ifdef (argc, argv, notflag)
  396. int argc OPTIONAL;
  397. char *argv[];
  398. int notflag;
  399. {
  400. AarrayPtr aa;
  401. char *cp;
  402. int retval = 0;
  403.  
  404.     cp = _variable_expansion (strdup (argv[1]));
  405.     aa = assoc_find (SetVariables, cp);
  406.     free (cp);
  407.     Curproc->condfalse = ((notflag && aa == NULLASSOC) || (!notflag && aa != NULLASSOC)) ? 0 : 1;
  408.     if (!Curproc->condfalse) {
  409.         cp = _variable_expansion (strdup (argv[2]));
  410.         retval = cmdparse (Cmds, cp, NULL);
  411.         free (cp);
  412.     }
  413.     return retval;
  414. }
  415.  
  416.  
  417. int
  418. doifstrequal (argc, argv, p)
  419. int argc;
  420. char *argv[];
  421. void *p OPTIONAL;
  422. {
  423.     return (_ifstrequal (argc, argv, 0));
  424. }
  425.  
  426.  
  427. int
  428. doifnstrequal (argc, argv, p)
  429. int argc;
  430. char *argv[];
  431. void *p OPTIONAL;
  432. {
  433.     return (_ifstrequal (argc, argv, 1));
  434. }
  435.  
  436.  
  437. int
  438. _ifstrequal (argc, argv, notflag)
  439. int argc OPTIONAL;
  440. char *argv[];
  441. int notflag;
  442. {
  443. int cmp;
  444. char *cp1, *cp2;
  445.  
  446.     cp1 = _variable_expansion (strdup (argv[1]));
  447.     cp2 = _variable_expansion (strdup (argv[2]));
  448.     cmp = strcmp (cp1, cp2);
  449.     free (cp1);
  450.     free (cp2);
  451.     Curproc->condfalse = ((notflag && cmp) || (!notflag && !cmp)) ? 0 : 1;
  452.     return 4;
  453. }
  454.  
  455.  
  456. int
  457. doifequal (argc, argv, p)
  458. int argc;
  459. char *argv[];
  460. void *p OPTIONAL;
  461. {
  462.     return (_ifequal (argc, argv, _EQUAL));
  463. }
  464.  
  465.  
  466. int
  467. doifnequal (argc, argv, p)
  468. int argc;
  469. char *argv[];
  470. void *p OPTIONAL;
  471. {
  472.     return (_ifequal (argc, argv, _NEQUAL));
  473. }
  474.  
  475.  
  476. int
  477. doifless (argc, argv, p)
  478. int argc;
  479. char *argv[];
  480. void *p OPTIONAL;
  481. {
  482.     return (_ifequal (argc, argv, _LESS));
  483. }
  484.  
  485.  
  486. int
  487. doifgreat (argc, argv, p)
  488. int argc;
  489. char *argv[];
  490. void *p OPTIONAL;
  491. {
  492.     return (_ifequal (argc, argv, _GREAT));
  493. }
  494.  
  495.  
  496. int
  497. doiflessequal (argc, argv, p)
  498. int argc;
  499. char *argv[];
  500. void *p OPTIONAL;
  501. {
  502.     return (_ifequal (argc, argv, _LESSEQUAL));
  503. }
  504.  
  505.  
  506. int
  507. doifgreatequal (argc, argv, p)
  508. int argc;
  509. char *argv[];
  510. void *p OPTIONAL;
  511. {
  512.     return (_ifequal (argc, argv, _GREATEQUAL));
  513. }
  514.  
  515.  
  516. int
  517. _ifequal (argc, argv, notflag)
  518. int argc OPTIONAL;
  519. char *argv[];
  520. int notflag;
  521. {
  522. int val1, val2;
  523. char *cp1, *cp2;
  524.  
  525.     cp1 = _variable_expansion (strdup (argv[1]));
  526.     cp2 = _variable_expansion (strdup (argv[2]));
  527.     val1 = atoi (cp1);
  528.     val2 = atoi (cp2);
  529.     free (cp1);
  530.     free (cp2);
  531.     if (notflag == _EQUAL)
  532.         Curproc->condfalse = (val1 == val2) ? 0 : 1;
  533.     else if (notflag == _NEQUAL)
  534.         Curproc->condfalse = (val1 != val2) ? 0 : 1;
  535.     else if (notflag == _LESS)
  536.         Curproc->condfalse = (val1 < val2) ? 0 : 1;
  537.     else if (notflag == _GREAT)
  538.         Curproc->condfalse = (val1 > val2) ? 0 : 1;
  539.     else if (notflag == _LESSEQUAL)
  540.         Curproc->condfalse = (val1 <= val2) ? 0 : 1;
  541.     else if (notflag == _GREATEQUAL)
  542.         Curproc->condfalse = (val1 >= val2) ? 0 : 1;
  543.     else
  544.         Curproc->condfalse = 1;
  545.     return 4;
  546. }
  547.  
  548.  
  549. int
  550. dowhile (argc, argv, p)
  551. int argc;
  552. char *argv[];
  553. void *p OPTIONAL;
  554. {
  555. int loop = 1;
  556. int retval;
  557.  
  558.     if (argc == 1 || (argc == 2 && argv[1][0] == '?'))
  559.         loop = 0;
  560.     do {
  561.         retval = doif (argc, argv, p);
  562.     } while (!retval && loop && !Curproc->condfalse);
  563.     Curproc->condfalse = 0;
  564.     return 0;
  565. }
  566.  
  567.  
  568. int
  569. dountil (argc, argv, p)
  570. int argc;
  571. char *argv[];
  572. void *p OPTIONAL;
  573. {
  574. int loop = 1;
  575. int retval;
  576. char *cp;
  577.  
  578.     if (argc >= 3) {
  579.         cp = argv[1];
  580.         argv[1] = argv[2];
  581.         argv[2] = cp;
  582.     }
  583.     if (argc == 1 || (argc == 2 && argv[1][0] == '?'))
  584.         loop = 0;
  585.     do {
  586.         if ((retval = subcmd (IFtab, argc, argv, p)) > 0)
  587.             if (Curproc->condfalse) {
  588.                 cp = _variable_expansion (strdup (argv[retval]));
  589.                 retval = cmdparse (Cmds, cp, NULL);
  590.                 free (cp);
  591.             }
  592.     } while (!retval && loop && Curproc->condfalse);
  593.     Curproc->condfalse = 0;
  594.     return 0;
  595. }
  596.  
  597.  
  598. #endif /* SCRIPTING */
  599.  
  600.  
  601. void
  602. variable_expansion (bp)
  603. struct mbuf **bp;
  604. {
  605. #ifdef SCRIPTING
  606. char *new;
  607.  
  608.     new = mallocw ((*bp)->cnt);
  609.     (void) pullup (bp, (unsigned char *) new, (*bp)->cnt);
  610.     new = _variable_expansion (new);
  611.     if (strlen (new)) {
  612.         *bp = pushdown (*bp, (int16)(strlen (new) + 1));
  613.         strcpy ((char *) (*bp)->data, new);
  614.     } else {
  615.         *bp = pushdown (*bp, 1);
  616.         (*bp)->data[0] = 0;
  617.     }
  618.     free (new);
  619. #endif
  620. }
  621.  
  622.  
  623. char *
  624. _variable_expansion (input)
  625. char *input;
  626. {
  627. #ifdef SCRIPTING
  628. char *cp, *cp2, *cp3, old, *alias, *new;
  629. int offset = 0, size;
  630. int inbrace = 0;
  631.  
  632.     /* analyze input, and if necessary, replace it with a new one */
  633.     rip (input);
  634.     cp = skipnonwhite (input);
  635.     old = *cp;
  636.     cp2 = cp;
  637.     if (old) {
  638.         *cp = 0;
  639.         if (old != '\n')
  640.             cp2++;
  641.     }
  642.     if ((alias = (char *) assoc_lookup (Aliases, input)) != NULLCHAR) {
  643.         new = mallocw (strlen (alias) + strlen (cp2) + 2);
  644.         sprintf (new, "%s%c%s", alias, old, cp2);
  645.         free (input);
  646.         input = new;
  647.     } else
  648.         *cp = old;
  649.  
  650. #if 1
  651.     /* now that alias expansion is complete, now we go for variable substitution */
  652.     for (offset = 0; offset < (int) strlen (input); offset++) {
  653.         cp = &input[offset];
  654.         switch (*cp) {
  655.             case '{':
  656.                 inbrace++;
  657.                 break;
  658.             case '}':
  659.                 if (inbrace)
  660.                     inbrace--;
  661.                 break;
  662.             case '$':
  663.                 if (inbrace)
  664.                     break;
  665.                 *cp = 0;
  666.                 cp2 = (cp + 1);
  667.                 switch (*cp2) {
  668.                     case '$':
  669.                         alias = cp;
  670.                         old = *cp2++;
  671.                         break;
  672.                     case '{':
  673.                         cp3 = strchr (cp2 + 1, '}');
  674.                         if (cp3) {
  675.                             alias = ++cp2;
  676.                             *cp3++ = 0;
  677.                             old = *cp3;
  678.                             cp2 = ++cp3;
  679.                         } else
  680.                             alias = cp;
  681.                         break;
  682.                     default:
  683.                         cp3 = strpbrk (cp2, "; \t\n");
  684.                         if (cp3 == NULLCHAR)
  685.                             cp3 = &cp2[strlen (cp2)];
  686.                         old = *cp3;
  687.                         if (old)
  688.                             *cp3++ = 0;
  689.                         alias = cp2;
  690.                         cp2 = cp3;
  691.                 }
  692.                 if (*alias)
  693.                     alias = (char *) assoc_lookup (SetVariables, alias);
  694.                 size = (int) ((alias) ? strlen (alias) : 0);
  695.                 new = mallocw (strlen (input) + (unsigned) size + strlen (cp2) + 2);
  696.                 sprintf (new, "%s%s%c%s", input, (alias) ? alias : "", old, cp2);
  697.                 free (input);
  698.                 input = new;
  699.                 break;
  700.             default:
  701.                 break;
  702.         }
  703.     }
  704. #endif
  705. #endif /* SCRIPTING */
  706.     return input;
  707. }
  708.